home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_100 / 159_01 / verb.c < prev    next >
C/C++ Source or Header  |  1990-05-03  |  16KB  |  1,048 lines
  1.  
  2.  /* VERB.C  no mods for V 1.43 */
  3.  
  4. #include "advent.h"
  5.  
  6. /*
  7.         Routine to process a transitive verb
  8. */
  9. VOID PASCAL trverb(VOID)
  10. {
  11.     switch (verb)
  12.     {
  13.     case CALM:
  14.     case WALK:
  15.     case QUIT:
  16.     case SCORE:
  17.     case FOO:
  18.     case BRIEF:
  19.     case SUSPEND:
  20.     case HOURS:
  21.     case LOG:
  22.         actspk(verb);
  23.         break;
  24.  
  25.     case TAKE:
  26.         vtake();
  27.         break;
  28.  
  29.     case DROP:
  30.         vdrop();
  31.         break;
  32.     case OPEN:
  33.     case LOCK:
  34.         vopen();
  35.         break;
  36.     case SAY:
  37.         vsay();
  38.         break;
  39.     case NOTHING:
  40.         rspeak(54);
  41.         break;
  42.     case ON:
  43.         von();
  44.         break;
  45.     case OFF:
  46.         voff();
  47.         break;
  48.     case WAVE:
  49.         vwave();
  50.         break;
  51.     case KILL:
  52.         vkill();
  53.         break;
  54.     case POUR:
  55.         vpour();
  56.         break;
  57.     case EAT:
  58.         veat();
  59.         break;
  60.     case DRINK:
  61.         vdrink();
  62.         break;
  63.     case RUB:
  64.         if (object != LAMP)
  65.         rspeak(76);
  66.         else
  67.         actspk(RUB);
  68.         break;
  69.     case THROW:
  70.         vthrow();
  71.         break;
  72.     case FEED:
  73.         vfeed();
  74.         break;
  75.     case FIND:
  76.     case INVENTORY:
  77.         vfind();
  78.         break;
  79.     case FILL:
  80.         vfill();
  81.         break;
  82.     case READ:
  83.         vread();
  84.         break;
  85.     case BLAST:
  86.         vblast();
  87.         break;
  88.     case BREAK:
  89.         vbreak();
  90.         break;
  91.     case WAKE:
  92.         vwake();
  93.         break;
  94.     case SAVE:
  95.         saveadv();
  96.         describe();
  97.         descitem();
  98.         break;
  99.     case RESTORE:
  100.         restore();
  101.         describe();
  102.         descitem();
  103.         break;
  104.     default:
  105.         printf("This verb is not implemented yet.\n");
  106.     }
  107.  
  108.     return;
  109. }
  110.  
  111. /*
  112.         CARRY TAKE etc.
  113. */
  114. VOID PASCAL vtake(VOID)
  115. {
  116.     auto     SHORT    msg;
  117.     auto     SHORT    i;
  118.  
  119.     if (toting(object))
  120.     {
  121.     actspk(verb);
  122.     return;
  123.     }
  124.  
  125.     /* special case objects and fixed objects */
  126.     msg = 25;
  127.     if (object == PLANT && prop[PLANT] <= 0)
  128.     msg = 115;
  129.     if (object == BEAR && prop[BEAR] == 1)
  130.     msg = 169;
  131.     if (object == CHAIN && prop[BEAR] != 0)
  132.     msg = 170;
  133.  
  134.     if (fixed[object])
  135.     {
  136.     rspeak(msg);
  137.     return;
  138.     }
  139.  
  140.     /* special case for liquids */
  141.     if (object == WATER || object == OIL)
  142.     {
  143.     if (!here(BOTTLE) || liq() != object)
  144.     {
  145.         object = BOTTLE;
  146.         if (toting(BOTTLE) && prop[BOTTLE] == 1)
  147.         {
  148.         vfill();
  149.         return;
  150.         }
  151.  
  152.         if (prop[BOTTLE] != 1)
  153.         msg = 105;
  154.         if (!toting(BOTTLE))
  155.         msg = 104;
  156.         rspeak(msg);
  157.         return;
  158.     }
  159.  
  160.     object = BOTTLE;
  161.     }
  162.  
  163.     if (holding >= 7)
  164.     {
  165.     rspeak(92);
  166.     return;
  167.     }
  168.  
  169.     /* special case for bird. */
  170.     if (object == BIRD && prop[BIRD] == 0)
  171.     {
  172.     if (toting(ROD))
  173.     {
  174.         rspeak(26);
  175.         return;
  176.     }
  177.  
  178.     if (!toting(CAGE))
  179.     {
  180.         rspeak(27);
  181.         return;
  182.     }
  183.  
  184.     prop[BIRD] = 1;
  185.     }
  186.  
  187.     if ((object == BIRD || object == CAGE) && prop[BIRD] != 0)
  188.     carry((BIRD + CAGE) - object, loc);
  189.  
  190.     carry(object, loc);
  191.  
  192.     /* handle liquid in bottle */
  193.     i = liq();
  194.     if (object == BOTTLE && i != 0)
  195.     place[i] = -1;
  196.     rspeak(54);
  197.  
  198.     return;
  199. }
  200.  
  201. /*
  202.         DROP etc.
  203. */
  204. VOID PASCAL vdrop(VOID)
  205. {
  206.     auto SHORT      i;
  207.  
  208.     /* check for dynamite */
  209.     if (toting(ROD2) && object == ROD && !toting(ROD))
  210.     object = ROD2;
  211.  
  212.     if (!toting(object))
  213.     {
  214.     actspk(verb);
  215.     return;
  216.     }
  217.  
  218.     /* snake and bird */
  219.     if (object == BIRD && here(SNAKE))
  220.     {
  221.     rspeak(30);
  222.     if (closed)
  223.         dwarfend();
  224.     dstroy(SNAKE);
  225.     prop[SNAKE] = -1;
  226.     }
  227.     else            /* coins and vending machine */
  228.     {
  229.     if (object == COINS && here(VEND))
  230.     {
  231.         dstroy(COINS);
  232.         drop(BATTERIES, loc);
  233.         pspeak(BATTERIES, 0);
  234.         return;
  235.     }
  236.     else            /* bird and dragon (ouch!!) */
  237.     {
  238.         if (object == BIRD && at(DRAGON) && prop[DRAGON] == 0)
  239.         {
  240.         rspeak(154);
  241.         dstroy(BIRD);
  242.         prop[BIRD] = 0;
  243.         if (place[SNAKE] != 0)
  244.             ++tally2;
  245.         return;
  246.         }
  247.     }
  248.     }
  249.  
  250.     /* Bear and troll */
  251.     if (object == BEAR && at(TROLL))
  252.     {
  253.     rspeak(163);
  254.     move(TROLL, 0);
  255.     move((TROLL + MAXOBJ), 0);
  256.     move(TROLL2, 117);
  257.     move((TROLL2 + MAXOBJ), 122);
  258.     juggle(CHASM);
  259.     prop[TROLL] = 2;
  260.     }
  261.     else            /* vase */
  262.     {
  263.     if (object == VASE)
  264.     {
  265.         if (loc == 96)
  266.         rspeak(54);
  267.         else
  268.         {
  269.         prop[VASE] = at(PILLOW) ? 0 : 2;
  270.         pspeak(VASE, prop[VASE] + 1);
  271.         if (prop[VASE] != 0)
  272.             fixed[VASE] = -1;
  273.         }
  274.     }
  275.     }
  276.  
  277.     /* handle liquid and bottle */
  278.     i = liq();
  279.     if (i == object)
  280.     object = BOTTLE;
  281.  
  282.     if (object == BOTTLE && i != 0)
  283.     place[i] = 0;
  284.  
  285.     /* handle bird and cage */
  286.     if (object == CAGE && prop[BIRD] != 0)
  287.     drop(BIRD, loc);
  288.     if (object == BIRD)
  289.     prop[BIRD] = 0;
  290.     drop(object, loc);
  291.  
  292.     return;
  293. }
  294.  
  295. /*
  296.         LOCK, UNLOCK, OPEN, CLOSE etc.
  297. */
  298. VOID PASCAL vopen(VOID)
  299. {
  300.     auto SHORT      msg, oyclam;
  301.  
  302.     switch (object)
  303.     {
  304.     case CLAM:
  305.     case OYSTER:
  306.         oyclam = (object == OYSTER ? 1 : 0);
  307.         if (verb == LOCK)
  308.         msg = 61;
  309.         else
  310.         {
  311.         if (!toting(TRIDENT))
  312.             msg = 122 + oyclam;
  313.         else
  314.         {
  315.             if (toting(object))
  316.             msg = 120 + oyclam;
  317.             else
  318.             {
  319.             msg = 124 + oyclam;
  320.             dstroy(CLAM);
  321.             drop(OYSTER, loc);
  322.             drop(PEARL, 105);
  323.             }
  324.         }
  325.         }
  326.         break;
  327.     case DOOR:
  328.         msg = (prop[DOOR] == 1 ? 54 : 111);
  329.         break;
  330.     case CAGE:
  331.         msg = 32;
  332.         break;
  333.     case KEYS:
  334.         msg = 55;
  335.         break;
  336.     case CHAIN:
  337.         if (!here(KEYS))
  338.         msg = 31;
  339.         else
  340.         {
  341.         if (verb == LOCK)
  342.         {
  343.             if (prop[CHAIN] != 0)
  344.             msg = 34;
  345.             else
  346.             if (loc != 130)
  347.             msg = 173;
  348.             else
  349.             {
  350.             prop[CHAIN] = 2;
  351.             if (toting(CHAIN))
  352.                 drop(CHAIN, loc);
  353.             fixed[CHAIN] = -1;
  354.             msg = 172;
  355.             }
  356.         }
  357.         else
  358.         {
  359.             if (prop[BEAR] == 0)
  360.             msg = 41;
  361.             else
  362.             {
  363.             if (prop[CHAIN] == 0)
  364.                 msg = 37;
  365.             else
  366.             {
  367.                 prop[CHAIN] = 0;
  368.                 fixed[CHAIN] = 0;
  369.                 if (prop[BEAR] != 3)
  370.                 prop[BEAR] = 2;
  371.                 fixed[BEAR] = 2 - prop[BEAR];
  372.                 msg = 171;
  373.             }
  374.             }
  375.         }
  376.         }
  377.         break;
  378.     case GRATE:
  379.         if (!here(KEYS))
  380.         msg = 31;
  381.         else
  382.         {
  383.         if (closing)
  384.         {
  385.             if (!panic)
  386.             {
  387.             clock2 = 15;
  388.             ++panic;
  389.             }
  390.             msg = 130;
  391.         }
  392.         else
  393.         {
  394.             msg = 34 + prop[GRATE];
  395.             prop[GRATE] = (verb == LOCK ? 0 : 1);
  396.             msg += 2 * prop[GRATE];
  397.         }
  398.         }
  399.         break;
  400.     default:
  401.         msg = 33;
  402.     }
  403.     rspeak(msg);
  404.     return;
  405. }
  406.  
  407. /*
  408.         SAY etc.
  409. */
  410. VOID PASCAL vsay(VOID)
  411. {
  412.     auto SHORT      wtype, wval;
  413.  
  414.     analyze(word1, &wtype, &wval);
  415.     printf("Okay.\n%s\n", wval == SAY ? word2 : word1);
  416.     return;
  417. }
  418.  
  419. /*
  420.         ON etc.
  421. */
  422. VOID PASCAL von(VOID)
  423. {
  424.     if (!here(LAMP))
  425.     actspk(verb);
  426.     else
  427.     {
  428.     if (limit < 0)
  429.         rspeak(184);
  430.     else
  431.     {
  432.         prop[LAMP] = 1;
  433.         rspeak(39);
  434.         if (wzdark)
  435.         {
  436.         wzdark = 0;
  437.         describe();
  438.         descitem();
  439.         }
  440.     }
  441.     }
  442.  
  443.     return;
  444. }
  445.  
  446. /*
  447.         OFF etc.
  448. */
  449. VOID PASCAL voff(VOID)
  450. {
  451.     if (!here(LAMP))
  452.     actspk(verb);
  453.     else
  454.     {
  455.     prop[LAMP] = 0;
  456.     rspeak(40);
  457.     }
  458.  
  459.     return;
  460. }
  461.  
  462. /*
  463.         WAVE etc.
  464. */
  465. VOID PASCAL vwave(VOID)
  466. {
  467.     if (!toting(object) && (object != ROD || !toting(ROD2)))
  468.     rspeak(29);
  469.     else
  470.     {
  471.     if (object != ROD || !at(FISSURE) || !toting(object) || closing)
  472.         actspk(verb);
  473.     else
  474.     {
  475.         prop[FISSURE] = 1 - prop[FISSURE];
  476.         pspeak(FISSURE, 2 - prop[FISSURE]);
  477.     }
  478.     }
  479. }
  480.  
  481. /*
  482.         ATTACK, KILL etc.
  483. */
  484. VOID PASCAL vkill(VOID)
  485. {
  486.     auto SHORT      msg;
  487.     auto SHORT      i;
  488.  
  489.     switch (object)
  490.     {
  491.     case BIRD:
  492.         if (closed)
  493.         msg = 137;
  494.         else
  495.         {
  496.         dstroy(BIRD);
  497.         prop[BIRD] = 0;
  498.         if (place[SNAKE] == 19)
  499.             ++tally2;
  500.         msg = 45;
  501.         }
  502.         break;
  503.     case 0:
  504.         msg = 44;
  505.         break;
  506.     case CLAM:
  507.     case OYSTER:
  508.         msg = 150;
  509.         break;
  510.     case SNAKE:
  511.         msg = 46;
  512.         break;
  513.     case DWARF:
  514.         if (closed)
  515.         dwarfend();
  516.         msg = 49;
  517.         break;
  518.     case TROLL:
  519.         msg = 157;
  520.         break;
  521.     case BEAR:
  522.         msg = 165 + (prop[BEAR] + 1) / 2;
  523.         break;
  524.     case DRAGON:
  525.         if (prop[DRAGON] != 0)
  526.         {
  527.         msg = 167;
  528.         break;
  529.         }
  530.         if (!yes(49, 0, 0))
  531.         break;
  532.         pspeak(DRAGON, 1);
  533.         prop[DRAG